%module CEGUIString

%{
#include "CEGUIString.h"
	%}

%import "CEGUIBase.i"
%include "std_string.i"

//#include <string.h>
//#include <stdexcept>
//#include <cstddef>

// Start of CEGUI namespace section
namespace CEGUI
{

class String
{
public:
	/*************************************************************************
		Integral Types
	*************************************************************************/
	typedef		utf32			value_type;					//!< Basic 'code point' type used for String (utf32)
	typedef		size_t			size_type;					//!< Unsigned type used for size values and indices
//	typedef		std::ptrdiff_t	difference_type;			//!< Signed type used for differences
	typedef		utf32&			reference;					//!< Type used for utf32 code point references
	typedef		const utf32&	const_reference;			//!< Type used for constant utf32 code point references
	typedef		utf32*			pointer;					//!< Type used for utf32 code point pointers
	typedef		const utf32*	const_pointer;				//!< Type used for constant utf32 code point pointers

	static const size_type		npos;						//!< Value used to represent 'not found' conditions and 'all code points' etc.

	String(void);

	~String(void);

//	String(const String& str);

	String(const std::string& std_str);

//	String(const std::string& std_str, size_type str_idx, size_type str_num = npos);

//	String(const utf8* utf8_str);

//	String(const utf8* utf8_str, size_type chars_len);

	String(const char* cstr);

	String(const char* chars, size_type chars_len);

//	size_type	size(void) const;

//	size_type	length(void) const;

//	bool	empty(void) const;

//	static size_type	max_size(void);

	int		compare(const String& str) const;

	int		compare(const std::string& std_str) const;

//	int		compare(const utf8* utf8_str) const;

	int		compare(const char* cstr) const;

//	reference	operator[](size_type idx);

//	value_type	operator[](size_type idx) const;

//	reference	at(size_type idx);

//	const_reference	at(size_type idx) const;

	const char* c_str(void) const;

//	const utf8* data(void) const;

//	utf32*	ptr(void);

//	const utf32*	ptr(void) const;

	String&	operator=(const String& str);

//	String&	assign(const String& str, size_type str_idx = 0, size_type str_num = npos);

	String&	operator=(const std::string& std_str);

//	String&	operator=(const utf8* utf8_str);

//	String&	assign(const utf8* utf8_str);

//	String&	operator=(utf32 code_point);

//	String&	assign(size_type num, utf32 code_point);

	String&	operator=(const char* cstr);

	String&	assign(const char* cstr);

	String&	assign(const char* chars, size_type chars_len);

//	void	swap(String& str);

//	String&	operator+=(const String& str);

	String&	operator+=(const std::string& std_str);

//	String&	operator+=(const utf8* utf8_str);

//	String& append(const utf8* utf8_str);

//	String& operator+=(utf32 code_point);

	String&	operator+=(const char* cstr);

	String& append(const char* cstr);

//	String&	insert(size_type idx, const String& str);

	String&	insert(size_type idx, const std::string& std_str);

//	String&	insert(size_type idx, const utf8* utf8_str);

	String&	insert(size_type idx, const char* cstr);

	void	clear(void);

	String& erase(void);

};


} // End of  CEGUI namespace section
